package com.smart.community.commons.handler;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;

/**
 * 错误日志处理器
 * @author Wu.Liang
 * @since 2024-12-19
 * @version 1.0.0
 */
@Slf4j
@Component
public class ErrorLogHandler {
    
    // 错误统计
    private final ConcurrentHashMap<String, AtomicLong> errorCountMap = new ConcurrentHashMap<>();
    private final AtomicLong totalErrorCount = new AtomicLong(0);
    
    /**
     * 处理错误日志
     * 
     * @param error 错误信息
     * @param context 错误上下文
     */
    public void handleError(String error, String context) {
        try {
            // 记录错误日志
            log.error("❌ 错误处理: context={}, error={}", context, error);
            
            // 统计错误数量
            incrementErrorCount(context);
            
            // 记录错误详情
            recordErrorDetails(error, context);
            
            // 发送错误通知
            sendErrorNotification(error, context);
            
        } catch (Exception e) {
            log.error("❌ 错误处理器异常", e);
        }
    }
    
    /**
     * 处理异常
     * 
     * @param exception 异常
     * @param context 异常上下文
     */
    public void handleException(Exception exception, String context) {
        try {
            // 记录异常日志
            log.error("❌ 异常处理: context={}, exception={}", context, exception.getMessage(), exception);
            
            // 统计异常数量
            incrementErrorCount(context);
            
            // 记录异常详情
            recordExceptionDetails(exception, context);
            
            // 发送异常通知
            sendExceptionNotification(exception, context);
            
        } catch (Exception e) {
            log.error("❌ 异常处理器异常", e);
        }
    }
    
    /**
     * 增加错误计数
     * 
     * @param context 错误上下文
     */
    private void incrementErrorCount(String context) {
        errorCountMap.computeIfAbsent(context, k -> new AtomicLong(0)).incrementAndGet();
        totalErrorCount.incrementAndGet();
        
        log.debug("📊 错误统计更新: context={}, count={}, total={}", 
                context, errorCountMap.get(context).get(), totalErrorCount.get());
    }
    
    /**
     * 记录错误详情
     * 
     * @param error 错误信息
     * @param context 错误上下文
     */
    private void recordErrorDetails(String error, String context) {
        // 这里可以添加具体的错误详情记录逻辑
        // 例如：记录到数据库、写入文件等
        
        log.debug("📝 记录错误详情: context={}, error={}", context, error);
    }
    
    /**
     * 记录异常详情
     * 
     * @param exception 异常
     * @param context 异常上下文
     */
    private void recordExceptionDetails(Exception exception, String context) {
        // 这里可以添加具体的异常详情记录逻辑
        // 例如：记录到数据库、写入文件等
        
        log.debug("📝 记录异常详情: context={}, exception={}", context, exception.getClass().getSimpleName());
    }
    
    /**
     * 发送错误通知
     * 
     * @param error 错误信息
     * @param context 错误上下文
     */
    private void sendErrorNotification(String error, String context) {
        // 这里可以添加具体的错误通知逻辑
        // 例如：发送邮件、短信、钉钉通知等
        
        log.debug("📢 发送错误通知: context={}, error={}", context, error);
    }
    
    /**
     * 发送异常通知
     * 
     * @param exception 异常
     * @param context 异常上下文
     */
    private void sendExceptionNotification(Exception exception, String context) {
        // 这里可以添加具体的异常通知逻辑
        // 例如：发送邮件、短信、钉钉通知等
        
        log.debug("📢 发送异常通知: context={}, exception={}", context, exception.getClass().getSimpleName());
    }
    
    /**
     * 获取错误统计信息
     * 
     * @return 错误统计信息
     */
    public ErrorStatistics getErrorStatistics() {
        ErrorStatistics statistics = new ErrorStatistics();
        statistics.setTotalErrorCount(totalErrorCount.get());
        statistics.setErrorCountMap(new ConcurrentHashMap<>(errorCountMap));
        
        return statistics;
    }
    
    /**
     * 清除错误统计
     */
    public void clearErrorStatistics() {
        errorCountMap.clear();
        totalErrorCount.set(0);
        
        log.info("🧹 错误统计已清除");
    }
    
    /**
     * 错误统计信息
     */
    public static class ErrorStatistics {
        private long totalErrorCount;
        private ConcurrentHashMap<String, AtomicLong> errorCountMap;
        
        // Getters and Setters
        public long getTotalErrorCount() { return totalErrorCount; }
        public void setTotalErrorCount(long totalErrorCount) { this.totalErrorCount = totalErrorCount; }
        
        public ConcurrentHashMap<String, AtomicLong> getErrorCountMap() { return errorCountMap; }
        public void setErrorCountMap(ConcurrentHashMap<String, AtomicLong> errorCountMap) { this.errorCountMap = errorCountMap; }
        
        @Override
        public String toString() {
            return String.format("ErrorStatistics{totalErrorCount=%d, errorCountMap=%s}", 
                    totalErrorCount, errorCountMap);
        }
    }
} 